//给你一个由小写英文字母组成的字符串 s 。 
//
// 请你找出字符串中两个字符 a1 和 a2 的出现频次之间的 最大 差值 diff = a1 - a2，这两个字符需要满足： 
//
// 
// a1 在字符串中出现 奇数次 。 
// a2 在字符串中出现 偶数次 。 
// 
//
// 返回 最大 差值。 
//
// 
//
// 示例 1： 
//
// 
// 输入：s = "aaaaabbc" 
// 
//
// 输出：3 
//
// 解释： 
//
// 
// 字符 'a' 出现 奇数次 ，次数为 5 ；字符 'b' 出现 偶数次 ，次数为 2 。 
// 最大差值为 5 - 2 = 3 。 
// 
//
// 示例 2： 
//
// 
// 输入：s = "abcabcab" 
// 
//
// 输出：1 
//
// 解释： 
//
// 
// 字符 'a' 出现 奇数次 ，次数为 3 ；字符 'c' 出现 偶数次 ，次数为 2 。 
// 最大差值为 3 - 2 = 1 。 
// 
//
// 
//
// 提示： 
//
// 
// 3 <= s.length <= 100 
// s 仅由小写英文字母组成。 
// s 至少由一个出现奇数次的字符和一个出现偶数次的字符组成。 
// 
//
// Related Topics 哈希表 字符串 计数 👍 6 👎 0


package LeetCode.editor.cn;


import java.util.*;
import java.util.stream.Collectors;

/**
 * @author ldltd
 * @date 2025-06-10 10:10:31
 * @description 3442.奇偶频次间的最大差值 I
 
 */
 
public class MaximumDifferenceBetweenEvenAndOddFrequencyI {
    public static void main(String[] args) {
    //测试代码
    MaximumDifferenceBetweenEvenAndOddFrequencyI fun = new MaximumDifferenceBetweenEvenAndOddFrequencyI();
    Solution solution= fun.new Solution();
    
    }

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public int maxDifference1(String s) {
        return s.chars()
                .mapToObj(c -> (char) c)
                .collect(Collectors.groupingBy(c -> c, Collectors.counting()))
                .values().stream()
                .collect(
                        Collectors.collectingAndThen(
                                Collectors.partitioningBy(
                                        count -> count % 2 == 1,
                                        Collectors.toList()
                                ),
                                partitioned -> {
                                    List<Long> oddFreqs = partitioned.get(true);
                                    List<Long> evenFreqs = partitioned.get(false);

                                    long maxOdd = oddFreqs.isEmpty() ? 0 : Collections.max(oddFreqs);
                                    long minEven = evenFreqs.isEmpty() ? 0 : Collections.min(evenFreqs);

                                    return (int) (maxOdd - minEven);
                                }
                        )
                );
    }
        public int maxDifference2(String s) {
            // 1. 统计每个字符的频率
            Map<Character, Integer> freqMap = new HashMap<>();
            for (char c : s.toCharArray()) {
                freqMap.put(c, freqMap.getOrDefault(c, 0) + 1);
            }

            // 2. 初始化奇数和偶数频次的极值
            int maxOdd = 1;    // 奇数频次的最大值
            int minEven = s.length();  // 偶数频次的最小值

            // 3. 遍历频次，更新 maxOdd 和 minEven
            boolean hasOdd = false;
            boolean hasEven = false;

            for (int count : freqMap.values()) {
                if (count % 2 == 1) {
                    hasOdd = true;
                    if (count > maxOdd) {
                        maxOdd = count;
                    }
                } else {
                    hasEven = true;
                    if (count < minEven) {
                        minEven = count;
                    }
                }
            }

            // 4. 处理边界情况
            if (!hasOdd || !hasEven) {
                return 0;  // 如果没有奇数频次或偶数频次，返回0
            }

            return maxOdd - minEven;
        }

    public int maxDifference(String s) {
        int[] cnt = new int[26];
        for (char b : s.toCharArray()) {
            cnt[b - 'a']++;
        }
        int max1 = 0;
        int min0 = Integer.MAX_VALUE;
        for (int c : cnt) {
            if (c % 2 > 0) {
                max1 = Math.max(max1, c);
            } else if (c > 0) {
                min0 = Math.min(min0, c);
            }
        }
        return max1 - min0;
    }

}
//leetcode submit region end(Prohibit modification and deletion)

}
